package com.platform.controller.bloc;

import com.platform.annotation.SysLog;
import com.platform.controller.AbstractController;
import com.platform.entity.SysDeptEntity;
import com.platform.entity.SysRoleEntity;
import com.platform.entity.SysUserEntity;
import com.platform.service.*;
import com.platform.utils.*;
import com.platform.validator.Assert;
import com.platform.validator.ValidatorUtils;
import com.platform.validator.group.AddGroup;
import com.platform.validator.group.UpdateGroup;
import org.apache.commons.lang.ArrayUtils;
import org.apache.shiro.crypto.hash.Sha256Hash;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 系统用户
 *
 * @author lipengjun
 * @email 939961241@qq.com
 * @date 2016年10月31日 上午10:40:10
 */
@RestController
@RequestMapping("/bloc/user")
public class BlocUserController extends AbstractController {
    @Autowired
    private SysUserService sysUserService;
    @Autowired
    private SysUserRoleService sysUserRoleService;
    @Autowired
    private SysDeptService sysDeptService;
    @Autowired
    private SysRoleService sysRoleService;

    /**
     * 所有用户列表
     */
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params) {

        /**
         * 1 查出所有用户
         * 2 判断当前登录用户是否为超级管理员
         * 3.1 如果是。返回所有用户
         * 3.2 如果不是
         *   3 查出当前登录用户的所属组织以、子组织、子子组织 放入zuzhiList
         *   4 判断查出的所有用户中，getDeptId()等于zuzhiList集合中任意一个组织的id，则将其放入resList中
         *   5 返回resList
         */

        //查询列表数据
        Query query = new Query(params);
        List<SysUserEntity> userList = sysUserService.queryList(query);
        int total = sysUserService.queryTotal(query);
        System.out.println("total查出的账户总数是 : " + total + "，个。。。");

        for(SysUserEntity sysUserEntity : userList) {
            System.out.println("全部用户 ： " + sysUserEntity);
            if("admin".equals(sysUserEntity.getUsername())) {
                System.out.println("移除超级管理员方法执行了，移除： " + sysUserEntity);
                userList.remove(sysUserEntity);
                total--;
                break;
            }
        }

        // 如果当前登录为超级管理员，则返回，且不再向下执行
        if (getUserId() == Constant.SUPER_ADMIN) {
            System.out.println("超级管理员登录，数据已返回!");
            PageUtils pageUtil = new PageUtils(userList, total, query.getLimit(), query.getPage());
            return R.ok().put("page", pageUtil);
        }

        // 获取当前登录用户所属组织id
        Long deptId = getDeptId();

        // 获得当前登录用户的组织信息
        SysDeptEntity curryUserDept = sysDeptService.queryObject(deptId);

        List<Long> sunDeptId = new ArrayList<>();

        // 如果登录账户为代理商
        if(curryUserDept.getLevel() == SysDeptEntity.DAILISHANG) {
            // 获取当前登录代理商的所有服务商id
            List<Long> queryDetpIdList = sysDeptService.queryDetpIdList(deptId);
            sunDeptId.addAll(queryDetpIdList);
        }

        // 如果登录账户为机构
        if(curryUserDept.getLevel() == SysDeptEntity.JIGOU) {
            // 获取当前登录机构的所有代理商id
            List<Long> queryDaiLiIdList = sysDeptService.queryDetpIdList(deptId);
            sunDeptId.addAll(queryDaiLiIdList);

            // 获取当前登录机构的所有代理商的所有服务商id
            for(Long id : queryDaiLiIdList) {
                List<Long> queryJiGouIdList = sysDeptService.queryDetpIdList(id);
                sunDeptId.addAll(queryJiGouIdList);
            }
        }

        List<SysUserEntity> resUser = new ArrayList<>();
        for(SysUserEntity sysUserEntity : userList) {
            Long tempId = sysUserEntity.getDeptId();

            for(Long sunId : sunDeptId) {
                if(sunId == tempId) {
                    resUser.add(sysUserEntity);
                    break;
                }
            }
        }
        total = resUser.size();

        PageUtils pageUtil = new PageUtils(resUser, total, query.getLimit(), query.getPage());
        return R.ok().put("page", pageUtil);
    }

    /**
     * 获取登录的用户信息
     */
    @RequestMapping("/info")
    public R info() {
        return R.ok().put("user", getUser());
    }

    /**
     * 修改登录用户密码
     */
    @SysLog("修改密码")
    @RequestMapping("/password")
    public R password(String password, String newPassword) {
        Assert.isBlank(newPassword, "新密码不为能空");

        //sha256加密
        password = new Sha256Hash(password).toHex();
        //sha256加密
        newPassword = new Sha256Hash(newPassword).toHex();

        //更新密码
        int count = sysUserService.updatePassword(getUserId(), password, newPassword);
        if (count == 0) {
            return R.error("原密码不正确");
        }

        //退出
        ShiroUtils.logout();

        return R.ok();
    }

    /**
     * 用户信息
     */
    @RequestMapping("/info/{userId}")
    public R info(@PathVariable("userId") Long userId) {
        SysUserEntity user = sysUserService.queryObject(userId);

        //获取用户所属的角色列表
        List<Long> roleIdList = sysUserRoleService.queryRoleIdList(userId);
        user.setRoleIdList(roleIdList);

        return R.ok().put("user", user);
    }

    /**
     * 保存用户
     */
    @SysLog("保存用户")
    @RequestMapping("/save")
    public R save(@RequestBody SysUserEntity user) {
        // TODO
        ValidatorUtils.validateEntity(user, AddGroup.class);

        user.setCreateUserId(getUserId());
        sysUserService.save(user);

        return R.ok();
    }

    /**
     * 修改用户
     */
    @SysLog("修改用户")
    @RequestMapping("/update")
    public R update(@RequestBody SysUserEntity user) {
        // TODO
        ValidatorUtils.validateEntity(user, UpdateGroup.class);

        user.setCreateUserId(getUserId());
        sysUserService.update(user);

        return R.ok();
    }

    /**
     * 删除用户
     */
    @SysLog("删除用户")
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] userIds) {
        if (ArrayUtils.contains(userIds, 1L)) {
            return R.error("系统管理员不能删除");
        }

        if (ArrayUtils.contains(userIds, getUserId())) {
            return R.error("当前用户不能删除");
        }

        sysUserService.deleteBatch(userIds);

        return R.ok();
    }


    /**
     * 新增用户时，查找可选择的部门树
     */
    @RequestMapping("/tree")
    public R list() {
        Map<String, Object> map = new HashMap<>();
        //如果不是超级管理员，则只能查询本部门及子部门数据
        if (getUserId() != Constant.SUPER_ADMIN) {
            map.put("deptFilter", sysDeptService.getSubDeptIdList(getDeptId()));
        }
        List<SysDeptEntity> deptList = sysDeptService.queryList(map);
        return R.ok().put("list", deptList);
    }

    /**
     * 角色列表
     */
    @RequestMapping("/role")
    public R select() {
        Map<String, Object> map = new HashMap<>();
        // 查询所有角色
        List<SysRoleEntity> list = sysRoleService.queryList(map);

        // 创建结果集
        List<SysRoleEntity> resList = new ArrayList<>();

        // 从所有角色中取出机构角色、代理商角色、服务商角色放入结果集中
        for(SysRoleEntity sysRoleEntity : list){
            if("机构角色".equals(sysRoleEntity.getRoleName()) ||
                    "代理商角色".equals(sysRoleEntity.getRoleName()) ||
                    "服务商角色".equals(sysRoleEntity.getRoleName())) {
                System.out.println("查询角色，向结果集中添加角色 ： " + sysRoleEntity);
                resList.add(sysRoleEntity);
            }
        }

        // 如果当前登录用户为超级管理员，返回结果集
        if (getUserId() == Constant.SUPER_ADMIN) {
            return R.ok().put("list", resList);
        }

        SysDeptEntity currSysDeptEntity = sysDeptService.queryObject(getDeptId());

        // 如果当前登录用户为机构，从结果集中remove机构角色
        if(currSysDeptEntity.getLevel() == SysDeptEntity.JIGOU) {
            for (SysRoleEntity sysRoleEntity : resList) {
                if("机构角色".equals(sysRoleEntity.getRoleName())) {
                    System.out.println("登录用户为机构， 移除角色 ： " + sysRoleEntity);
                    resList.remove(sysRoleEntity);
                    break;
                }
            }
        }

        // 如果当前登录用户为代理商，从结果集中remove机构角色，代理商角色
        if(currSysDeptEntity.getLevel() == SysDeptEntity.DAILISHANG) {
            List<SysRoleEntity> tempList = new ArrayList<>();
            tempList.addAll(resList);
            for (SysRoleEntity sysRoleEntity : tempList) {
                if("机构角色".equals(sysRoleEntity.getRoleName()) || "代理商角色".equals(sysRoleEntity.getRoleName())) {
                    System.out.println("登录用户为代理， 移除角色 ： " + sysRoleEntity);
                    resList.remove(sysRoleEntity);
                }
            }
        }

        // 如果当前登录用户为服务商，清空结果集
        if(currSysDeptEntity.getLevel() == SysDeptEntity.FUWUSHANG) {
            System.out.println("登录用户为服务商， 移除所有角色");
            resList.clear();
        }

        // 返回结果集
        return R.ok().put("list", resList);
    }

}
